package com.atguigu.gulimall.search.thread;

import org.apache.ibatis.executor.Executor;

import java.security.AccessController;
import java.util.concurrent.*;

import static java.util.concurrent.Executors.*;

/**
 * @Author: fd
 * @Date 2021/7/27 9:30
 * @Description: 线程测试类
 */
public class ThreadTest {

	public static ExecutorService executor = newFixedThreadPool(10);

	public static void main(String[] args) throws ExecutionException, InterruptedException {
		System.out.println("main。。。。start");
		// 异步编排
		// CompletableFuture可以来创建启动一个异步任务

//		CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
//			System.out.println("当前线程:" + Thread.currentThread().getId());
//			int i = 10 / 2;
//			System.out.println("运行结果:" + i);
//		}, executor);

		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			System.out.println("当前线程:" + Thread.currentThread().getId());
			int i = 10 / 0;
			System.out.println("运行结果:" + i);
			return i;
		}, executor).whenComplete((res,exception) -> {
			// 虽然能得到异常信息，但是没法修改返回数据
			System.out.println("异步任务成功完成了，结果是:" + res + ";异常是:" + exception);
		}).exceptionally(throwable -> {
			// 可以感知异常，同时返回默认值
			return 10;
		});
		Integer integer = future.get();
		System.out.println("main。。。。end..." + integer);

	}

	//1）、继承 Thread
	//2）、实现 Runnable 接口
	//3）、实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常）
	//4）、线程池
	public void thread(String[] args) {
		//1）、继承 Thread
		//Thread01 thread01 = new Thread01();
		//thread01.start();

		// 2）、实现 Runnable 接口
		//Runable01 runable01 = new Runable01();
		//new Thread(runable01).start();

		// 3）、实现 Callable 接口
		// FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
		// new Thread(futureTask).start();
		// System.out.println(futureTask.get());

		// 业务代码里，以上三种启动线程的方式都不用，将所有的多线程异步任务交给线程池执行
		// new Thread(() -> System.out.println("hello")).start();

		// 4）、线程池
		// 当前系统中池只有一两个，每个异步任务，提交给线程池让他自己去执行就行
		// executor.execute(new Runable01());

		ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
				200, 10,
				TimeUnit.SECONDS,
				new LinkedBlockingDeque<>(100000),
				defaultThreadFactory(),
				new ThreadPoolExecutor.AbortPolicy());

		// core是0，所有都可以回收
		newCachedThreadPool();
		// 固定大小，core=max，都不可回收
		newFixedThreadPool(1);
		// 定时任务的线程池
		newScheduledThreadPool(1);
		// 单线程的线程池
		newSingleThreadExecutor();
	}

	//1）、继承 Thread
	public static class Thread01 extends Thread{
		@Override
		public void run() {
			System.out.println("当前线程:" + Thread.currentThread().getId());
			int i = 10/2;
			System.out.println("运行结果:" + i);
		}
	}

	//2）、实现 Runnable 接口
	public static class Runable01 implements Runnable{
		@Override
		public void run() {
			System.out.println("当前线程:" + Thread.currentThread().getId());
			int i = 10/2;
			System.out.println("运行结果:" + i);
		}
	}


	//3）、实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常）
	public static class Callable01 implements Callable<Integer> {
		@Override
		public Integer call() throws Exception {
			System.out.println("当前线程：" + Thread.currentThread().getId());
			int i = 10 / 2;
			System.out.println("运行结果：" + i);
			return i;
		}
	}

	//4）、线程池

}
